package com.jiyiren.retrofitdemo.utils.tool;

import android.content.ContentResolver;
import android.content.Context;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Environment;
import android.provider.MediaStore;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * Author:    ZhuWenWu
 * Version    V1.0
 * Date:      15/8/15 21:47
 * Description: 文件操作帮住工具类
 * Modification  History:
 * Date         	Author        		Version        	Description
 * -----------------------------------------------------------------------------------
 * 15/8/15      ZhuWenWu            1.0                    1.0
 * Why & What is modified:
 */
public class FileHelper {

    /**
     * 判断文件是否存在
     *
     * @param filePath 文件路径
     * @return true:存在 false:不存在
     */
    public static boolean isFileExists(String filePath) {
        return StringHelper.notEmpty(filePath) && new File(filePath).exists();
    }

    /**
     * 删除文件
     *
     * @param filePath 文件路径
     * @return true:成功 false:失败
     */
    public static boolean deleteFile(String filePath) {
        if (StringHelper.notEmpty(filePath)) {
            File file = new File(filePath);
            if (file.exists()) {
                return file.delete();
            }
        }

        return false;
    }

    /**
     * 判断是否有外置sd卡
     * @return
     */
    public static boolean existSDCard() {
        if (Environment.getExternalStorageState().equals(
                Environment.MEDIA_MOUNTED)) {
            return true;
        } else
            return false;
    }

    //创建根目录下的一个目录和文件
    public static String CreateFileCamePhoto(String parentName,String fileName){
        File f=new File(Environment.getExternalStorageDirectory(),parentName);
        if(!f.exists()){
            f.mkdirs();
        }
        File file=new File(f,fileName);
        if(!file.exists()){
            try {
                file.createNewFile();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return Environment.getExternalStorageDirectory()+"/"+parentName+"/"+fileName;
    }


    /**
     * 获得图片的路径地址
     * @param context
     * @param uri
     * @return
     */
    public static String getImageFilePathFromUri(final Context context, final Uri uri ) {
        if ( null == uri ) return null;
        final String scheme = uri.getScheme();
        String data = null;
        if ( scheme == null )
            data = uri.getPath();
        else if ( ContentResolver.SCHEME_FILE.equals( scheme ) ) {
            data = uri.getPath();
        } else if ( ContentResolver.SCHEME_CONTENT.equals( scheme ) ) {
            Cursor cursor = context.getContentResolver().query( uri, new String[] { MediaStore.Images.ImageColumns.DATA }, null, null, null );
            if ( null != cursor ) {
                if ( cursor.moveToFirst() ) {
                    int index = cursor.getColumnIndex( MediaStore.Images.ImageColumns.DATA );
                    if ( index > -1 ) {
                        data = cursor.getString( index );}
                }
                cursor.close();
            }
        }
        return data;
    }

    /**
     * 获得压缩图片bitmap
     * @param fileurl
     * @param reqWidth
     * @param reqHeight
     * @return
     */
    public static Bitmap getCompressBitmapFromFile(String fileurl,
                                                     int reqWidth, int reqHeight) {
        // 首先不加载图片,仅获取图片尺寸
        final BitmapFactory.Options options = new BitmapFactory.Options();
        // 当inJustDecodeBounds设为true时,不会加载图片仅获取图片尺寸信息
        options.inJustDecodeBounds = true;
        // 此时仅会将图片信息会保存至options对象内,decode方法不会返回bitmap对象
        BitmapFactory.decodeFile(fileurl, options);

        // 计算压缩比例,如inSampleSize=4时,图片会压缩成原图的1/4
        options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);

        // 当inJustDecodeBounds设为false时,BitmapFactory.decode...就会返回图片对象了
        options. inJustDecodeBounds = false;
        // 利用计算的比例值获取压缩后的图片对象
        return BitmapFactory.decodeFile(fileurl, options);
    }

    /**
     * 计算压缩比例
     * @param options
     * @param reqWidth
     * @param reqHeight
     * @return
     */
    public static int calculateInSampleSize(BitmapFactory.Options options,
                                            int reqWidth, int reqHeight) {
        // 保存图片原宽高值
        final int height = options. outHeight;
        final int width = options. outWidth;
        // 初始化压缩比例为1
        int inSampleSize = 1;

        // 当图片宽高值任何一个大于所需压缩图片宽高值时,进入循环计算系统
        if (height > reqHeight || width > reqWidth) {

            final int halfHeight = height / 2;
            final int halfWidth = width / 2;
            // 压缩比例值每次循环两倍增加,
            // 直到原图宽高值的一半除以压缩值后都~大于所需宽高值为止
            while ((halfHeight / inSampleSize) >= reqHeight
                    && (halfWidth / inSampleSize) >= reqWidth) {
                inSampleSize *= 2;
            }
        }
        return inSampleSize;
    }

    /**
     * 根据质量大小压缩图片
     * 质量压缩，循环压缩直到图片大小小于lastweighKB，比如lastweigh=100就代表100KB
     * 这个方法和下面的getimage方法可以合用，先宽高压缩再质量压缩
     * @param image 图片bitmap
     * @param lastweigh 图片大小不大于lastweigih KB
     * @return
     */
    public static Bitmap compressImageByWeight(Bitmap image,int lastweigh) {

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        image.compress(Bitmap.CompressFormat.JPEG, 100, baos);//质量压缩方法，这里100表示不压缩，把压缩后的数据存放到baos中
        int options = 100;
        while ( baos.toByteArray().length / 1024>lastweigh) { //循环判断如果压缩后图片是否大于100kb,大于继续压缩
            baos.reset();//重置baos即清空baos
            options -= 20;//每次都减少10
            if(options<=0){
                break;
            }
            image.compress(Bitmap.CompressFormat.JPEG, options, baos);//这里压缩options%，把压缩后的数据存放到baos中
        }
        ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());//把压缩后的数据baos存放到ByteArrayInputStream中
        Bitmap bitmap = BitmapFactory.decodeStream(isBm, null, null);//把ByteArrayInputStream数据生成图片
        return bitmap;
    }

    /**
     * 根据图片边界也就是宽高压缩
     * @param srcPath
     * @param lasth  不大于lasth 高
     * @param lastw  不大于lastw 宽
     * @return
     */
    public static Bitmap compressImageByBounds(String srcPath,float lasth,float lastw) {
        BitmapFactory.Options newOpts = new BitmapFactory.Options();
        newOpts.inJustDecodeBounds = true;
        Bitmap bitmap;
        bitmap= BitmapFactory.decodeFile(srcPath,newOpts);//此时返回bm为空

        newOpts.inJustDecodeBounds = false;
        int w = newOpts.outWidth;
        int h = newOpts.outHeight;
        //现在主流手机比较多是800*480分辨率，所以高和宽我们设置为
        float hh = lasth;//这里设置高度为800f
        float ww = lastw;//这里设置宽度为480f
        //缩放比。由于是固定比例缩放，只用高或者宽其中一个数据进行计算即可
        int be = 1;//be=1表示不缩放
        if (w > h && w > ww) {//如果宽度大的话根据宽度固定大小缩放
            be = (int) (w / ww);
        } else if (w < h && h > hh) {//如果高度高的话根据宽度固定大小缩放
            be = (int) (h / hh);
        }
        if (be <= 0)
            be = 1;
        newOpts.inSampleSize = be;//设置缩放比例
        //重新读入图片，注意此时已经把options.inJustDecodeBounds 设回false了
        bitmap = BitmapFactory.decodeFile(srcPath, newOpts);
        return bitmap;
    }

    /**
     * 根据质量和尺寸进行压缩
     * @param srcPath
     * @param lastweigh
     * @param lasth
     * @param lastw
     * @return
     */
    public static Bitmap compressImageByAll(String srcPath,int lastweigh,float lasth,float lastw){
        return  compressImageByWeight(compressImageByBounds(srcPath,lasth,lastw),lastweigh);
    }

    //将bitmap保存到制定路径
    public static void SavePhoto(Bitmap bitmap,String path){
        FileOutputStream fos=null;
        try {
            File file=new File(path);
            if(!file.exists()){
                file.createNewFile();
            }
            fos=new FileOutputStream(file);
            bitmap.compress(Bitmap.CompressFormat.JPEG,70, fos);//100无压缩
            //保存为png格式，图片压缩质量为75，对于png来说这个参数会被忽略
            //jpg则使用CompressFormat.JPEG
            fos.flush();
            fos.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static String checkAndMkdirs(String dir) {
        File file = new File(dir);
        if (!file.exists()) {
            file.mkdirs();
        }
        return dir;
    }

//    public static String getAppPath() {
//        return checkAndMkdirs(AppContact.FILE_DATA_ROOT_PATH);
//    }
//
//    public static String getAvatarDir() {
//        return checkAndMkdirs(AppContact.FILE_DATA_AVATAR_PATH);
//    }
//
//    public static String getPicturePath() {
//        return checkAndMkdirs(AppContact.FILE_DATA_PICTURE_PATH);
//    }
//    public static String getAudioPath() {
//        return checkAndMkdirs(AppContact.FILE_DATA_AUDIO_PATH);
//    }
}
